M

MLOG

O'zbek

Schema Stitching yordamida GraphQL Federatsiyasi kuchini oching. Masshtablash va texnik xizmat ko'rsatishni yaxshilab, bir nechta servislardan yagona GraphQL API'ni yaratishni o'rganing.

GraphQL Federatsiyasi: Schema Stitching - To'liq Qo'llanma

Zamonaviy ilovalarni ishlab chiqishning doimiy rivojlanayotgan landshaftida masshtablanuvchi va texnik xizmat ko'rsatish oson bo'lgan arxitekturalarga ehtiyoj birinchi darajali ahamiyatga ega bo'ldi. O'zining modulliligi va mustaqil joylashtirilishi bilan mikroservislar mashhur yechimga aylandi. Biroq, ko'plab mikroservislarni boshqarish, ayniqsa mijoz ilovalariga yagona API'ni taqdim etishda murakkabliklarni keltirib chiqarishi mumkin. Aynan shu yerda GraphQL Federatsiyasi va xususan, Schema Stitching yordamga keladi.

GraphQL Federatsiyasi nima?

GraphQL Federatsiyasi bu bir nechta asosiy GraphQL servislaridan (ko'pincha mikroservislarni ifodalovchi) yagona, birlashgan GraphQL API'ni yaratishga imkon beruvchi kuchli arxitektura. U dasturchilarga turli servislar bo'ylab ma'lumotlarni xuddi yagona graf kabi so'rash imkonini beradi, bu esa mijoz tajribasini soddalashtiradi va mijoz tomonida murakkab orkestratsiya mantig'iga bo'lgan ehtiyojni kamaytiradi.

GraphQL Federatsiyasining ikkita asosiy yondashuvi mavjud:

Ushbu maqola Schema Stitching ga e'tibor qaratadi, uning tushunchalari, afzalliklari, cheklovlari va amaliyotda qo'llanilishini o'rganadi.

Schema Stitching'ni tushunish

Schema Stitching - bu bir nechta GraphQL sxemalarini yagona, yaxlit sxemaga birlashtirish jarayoni. Ushbu birlashgan sxema fasad vazifasini o'taydi va asosiy servislar murakkabligini mijozdan yashiradi. Mijoz tikilgan sxemaga so'rov yuborganida, shlyuz so'rovni tegishli asosiy servis(lar)ga aqlli ravishda yo'naltiradi, ma'lumotlarni oladi va natijalarni mijozga qaytarishdan oldin birlashtiradi.

Buni quyidagicha tasavvur qiling: Sizda har biri turli xil taomlarga ixtisoslashgan bir nechta restoranlar (servislar) bor. Schema Stitching - bu har bir restorandagi barcha taomlarni birlashtirgan universal menyu. Xaridor (mijoz) universal menyudan buyurtma berganida, buyurtma aqlli ravishda tegishli restoran oshxonalariga yo'naltiriladi, ovqat tayyorlanadi va keyin xaridorga bitta yetkazib berish uchun birlashtiriladi.

Schema Stitching'dagi asosiy tushunchalar

Schema Stitching'ning afzalliklari

Schema Stitching mikroservis arxitekturasini qabul qilayotgan tashkilotlar uchun bir nechta jozibador afzalliklarni taklif etadi:

Schema Stitching'ning cheklovlari

Schema Stitching ko'plab afzalliklarni taklif qilsa-da, uning cheklovlaridan xabardor bo'lish muhim:

Schema Stitching'ni amaliyotda qo'llash

Keling, Node.js va graphql-tools kutubxonasi (sxema tikish uchun mashhur tanlov) yordamida Schema Stitching'ni qanday amalga oshirishning soddalashtirilgan misolini ko'rib chiqamiz. Bu misol ikkita mikroservisni o'z ichiga oladi: Foydalanuvchi Servisi va Mahsulot Servisi.

1. Masofaviy sxemalarni aniqlash

Birinchidan, har bir masofaviy servis uchun GraphQL sxemalarini aniqlang.

Foydalanuvchi Servisi (user-service.js):


const { buildSchema } = require('graphql');

const userSchema = buildSchema(`
  type User {
    id: ID!
    name: String
    email: String
  }

  type Query {
    user(id: ID!): User
  }
`);

const users = [
  { id: '1', name: 'Alice Smith', email: 'alice@example.com' },
  { id: '2', name: 'Bob Johnson', email: 'bob@example.com' },
];

const userRoot = {
  user: (args) => users.find(user => user.id === args.id),
};

module.exports = {
  schema: userSchema,
  rootValue: userRoot,
};

Mahsulot Servisi (product-service.js):


const { buildSchema } = require('graphql');

const productSchema = buildSchema(`
  type Product {
    id: ID!
    name: String
    price: Float
    userId: ID!  # Foreign key to User Service
  }

  type Query {
    product(id: ID!): Product
  }
`);

const products = [
  { id: '101', name: 'Laptop', price: 1200, userId: '1' },
  { id: '102', name: 'Smartphone', price: 800, userId: '2' },
];

const productRoot = {
  product: (args) => products.find(product => product.id === args.id),
};

module.exports = {
  schema: productSchema,
  rootValue: productRoot,
};

2. Shlyuz Servisini yaratish

Endi, ikkita sxemani bir-biriga tikadigan shlyuz servisini yarating.

Shlyuz Servisi (gateway.js):


const { stitchSchemas } = require('@graphql-tools/stitch');
const { makeRemoteExecutableSchema } = require('@graphql-tools/wrap');
const { graphqlHTTP } = require('express-graphql');
const express = require('express');
const { introspectSchema } = require('@graphql-tools/wrap');
const { printSchema } = require('graphql');
const fetch = require('node-fetch');

async function createRemoteSchema(uri) {
  const fetcher = async (params) => {
    const response = await fetch(uri, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify(params),
    });
    return response.json();
  };

  const schema = await introspectSchema(fetcher);
  return makeRemoteExecutableSchema({
    schema,
    fetcher,
  });
}

async function main() {
  const userSchema = await createRemoteSchema('http://localhost:4001/graphql');
  const productSchema = await createRemoteSchema('http://localhost:4002/graphql');

  const stitchedSchema = stitchSchemas({
    subschemas: [
      { schema: userSchema },
      { schema: productSchema },
    ],
    typeDefs: `
      extend type Product {
        user: User
      }
    `,
    resolvers: {
      Product: {
        user: {
          selectionSet: `{ userId }`,
          resolve(product, args, context, info) {
            return info.mergeInfo.delegateToSchema({
              schema: userSchema,
              operation: 'query',
              fieldName: 'user',
              args: {
                id: product.userId,
              },
              context,
              info,
            });
          },
        },
      },
    },
  });

  const app = express();
  app.use('/graphql', graphqlHTTP({
    schema: stitchedSchema,
    graphiql: true,
  }));

  app.listen(4000, () => console.log('Gateway server running on http://localhost:4000/graphql'));
}

main().catch(console.error);

3. Servislarni ishga tushirish

Foydalanuvchi Servisi va Mahsulot Servisini turli portlarda ishga tushirishingiz kerak bo'ladi. Masalan:

Foydalanuvchi Servisi (port 4001):


const express = require('express');
const { graphqlHTTP } = require('express-graphql');
const { schema, rootValue } = require('./user-service');

const app = express();
app.use('/graphql', graphqlHTTP({
  schema: schema,
  rootValue: rootValue,
  graphiql: true,
}));

app.listen(4001, () => console.log('User service running on http://localhost:4001/graphql'));

Mahsulot Servisi (port 4002):


const express = require('express');
const { graphqlHTTP } = require('express-graphql');
const { schema, rootValue } = require('./product-service');

const app = express();
app.use('/graphql', graphqlHTTP({
  schema: schema,
  rootValue: rootValue,
  graphiql: true,
}));

app.listen(4002, () => console.log('Product service running on http://localhost:4002/graphql'));

4. Tikilgan sxemaga so'rov yuborish

Endi siz tikilgan sxemaga shlyuz orqali (4000-portda ishlayotgan) so'rov yuborishingiz mumkin. Siz quyidagi kabi so'rovni bajarishingiz mumkin:


query {
  product(id: "101") {
    id
    name
    price
    user {
      id
      name
      email
    }
  }
}

Ushbu so'rov "101" ID'li mahsulotni oladi va shuningdek, Foydalanuvchi Servisidan bog'liq foydalanuvchini olib keladi, bu esa Schema Stitching'ning bitta so'rovda bir nechta servislar bo'ylab ma'lumotlarni so'rashga qanday imkon berishini ko'rsatadi.

Ilg'or Schema Stitching texnikalari

Asosiy misoldan tashqari, Schema Stitching implementatsiyangizni yaxshilash uchun foydalanish mumkin bo'lgan ba'zi ilg'or texnikalar mavjud:

Schema Stitching va Apollo Federation o'rtasida tanlov

Schema Stitching GraphQL Federatsiyasi uchun munosib variant bo'lsa-da, Apollo Federation o'zining ilg'or xususiyatlari va yaxshilangan dasturchi tajribasi tufayli yanada ommalashgan tanlovga aylandi. Quyida ikki yondashuvning taqqoslanishi keltirilgan:

Xususiyat Schema Stitching Apollo Federation
Sxema ta'rifi Mavjud GraphQL sxema tilidan foydalanadi Direktivalarga ega deklarativ sxema tilidan foydalanadi
So'rovni rejalashtirish Qo'lda so'rov delegatsiyasini talab qiladi Apollo Gateway tomonidan avtomatik so'rov rejalashtirish
Tur kengaytmalari Cheklangan qo'llab-quvvatlash Tur kengaytmalari uchun o'rnatilgan qo'llab-quvvatlash
Kalit direktivalari Qo'llab-quvvatlanmaydi Obyektlarni aniqlash uchun @key direktivasidan foydalanadi
Taqsimlangan kuzatuv Qo'lda amalga oshirishni talab qiladi Taqsimlangan kuzatuv uchun o'rnatilgan qo'llab-quvvatlash
Asboblar va Ekotizim Kamroq yetuk asboblar Ko'proq yetuk asboblar va katta hamjamiyat
Murakkablik Katta tizimlarda boshqarish murakkab bo'lishi mumkin Katta va murakkab tizimlar uchun mo'ljallangan

Qachon Schema Stitching'ni tanlash kerak:

Qachon Apollo Federation'ni tanlash kerak:

Haqiqiy dunyo misollari va qo'llash holatlari

Quyida GraphQL Federatsiyasi, jumladan Schema Stitching'dan qanday foydalanish mumkinligiga oid haqiqiy dunyo misollari keltirilgan:

Schema Stitching uchun eng yaxshi amaliyotlar

Muvaffaqiyatli Schema Stitching implementatsiyasini ta'minlash uchun ushbu eng yaxshi amaliyotlarga amal qiling:

Xulosa

Schema Stitching bilan GraphQL Federatsiyasi mikroservislar arxitekturasida bir nechta servislardan yagona API'lar yaratish uchun kuchli yondashuvni taklif etadi. Uning asosiy tushunchalari, afzalliklari, cheklovlari va amalga oshirish texnikasini tushunib, siz ma'lumotlarga kirishni soddalashtirish, masshtablanuvchanlikni yaxshilash va texnik xizmat ko'rsatishni kuchaytirish uchun Schema Stitching'dan foydalanishingiz mumkin. Apollo Federation yanada ilg'or yechim sifatida paydo bo'lgan bo'lsa-da, Schema Stitching oddiyroq stsenariylar uchun yoki mavjud GraphQL servislarni birlashtirishda munosib variant bo'lib qolmoqda. O'z tashkilotingiz uchun eng yaxshi yondashuvni tanlash uchun maxsus ehtiyojlaringiz va talablaringizni diqqat bilan ko'rib chiqing.